/*
 * Copyright 2018 JDCLOUD.COM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http:#www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * 云物理服务器
 * 云物理服务器相关接口
 *
 * OpenAPI spec version: v1
 * Contact: 
 *
 * NOTE: This class is auto generated by the jdcloud code generator program.
 */


using JDCloudSDK.Core.Auth;
using JDCloudSDK.Core.Client;
using JDCloudSDK.Core.Http;
using JDCloudSDK.Cps.Apis;
using JDCloudSDK.Cps.Model;
using System;
using System.Collections.Generic;
using System.Text;
#if NET40||NET35
#else
using System.Threading.Tasks;
#endif

namespace JDCloudSDK.Cps.Client
{
    /// <summary>
    ///  云物理服务器
    ///  云物理服务器相关接口
    ///  Cps Api 客户端
    ///</summary>
    public class CpsClient : JdcloudClient
    {

        /// <summary>
        ///  默认私有构造函数
        /// </summary>
        private CpsClient()
        {

        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="environment">sdk 环境配置信息</param>
        public CpsClient(CredentialsProvider credentialsProvider, HttpRequestConfig httpRequestConfig,SDKEnvironment environment)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
            this.environment = environment;
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="credentialsProvider">认证信息</param>
        public CpsClient(CredentialsProvider credentialsProvider,HttpRequestConfig httpRequestConfig)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        /// 默认构造函数，
        /// 注意如果使用此方法 httpRequestConfig 使用的http 请求 schema 为Https
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        public CpsClient(CredentialsProvider credentialsProvider)
        {
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        ///  版本号 1.2.3
        ///</summary>
        public const string ClientVersion = "1.2.3";

        private const string apiVersion = "v1";
        private const string userAgentPrefix = "JdcloudSdkDotNet";
        private const string defaultEndpoint = "cps.jdcloud-api.com";
        private const string serviceName = "cps";
        private const string userAgent = userAgentPrefix + "/" + ClientVersion + " " + serviceName + "/" + apiVersion;


        private SDKEnvironment environment = new SDKEnvironment(defaultEndpoint);
        private CredentialsProvider credentialsProvider;
        private HttpRequestConfig httpRequestConfig;

        /// <summary>
        ///  获取证书信息
        ///</summary>
        public override CredentialsProvider CredentialsProvider   { get { return credentialsProvider; } }

        /// <summary>
        ///  获取http 客户端配置信息
        ///</summary>
        public override HttpRequestConfig HttpRequestConfig { get { return httpRequestConfig; } }

        /// <summary>
        ///  获取sdk环境配置信息
        ///</summary>
        public override SDKEnvironment SDKEnvironment { get { return environment; } }

        /// <summary>
        ///  获取用户自定义浏览器识别字符串
        ///</summary>
        public override string UserAgent { get { return userAgent; } }

        /// <summary>
        ///  获取服务名称
        ///</summary>
        public override string ServiceName { get { return serviceName; } }

        /// <summary>
        ///  获取版本号
        ///</summary>
        public override string Version { get { return apiVersion; } }



#if NET40||NET35
        /// <summary>
        ///  查询后端服务器列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeServersResponse DescribeServers(DescribeServersRequest request) {
            return  new DescribeServersExecutor().Client(this).Execute<DescribeServersResponse, DescribeServersResult, DescribeServersRequest>(request);
        }
#else
        /// <summary>
        ///  查询后端服务器列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeServersResponse> DescribeServers(DescribeServersRequest request) {
            return await new DescribeServersExecutor().Client(this).Execute<DescribeServersResponse, DescribeServersResult, DescribeServersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询子网详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSubnetResponse DescribeSubnet(DescribeSubnetRequest request) {
            return  new DescribeSubnetExecutor().Client(this).Execute<DescribeSubnetResponse, DescribeSubnetResult, DescribeSubnetRequest>(request);
        }
#else
        /// <summary>
        ///  查询子网详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSubnetResponse> DescribeSubnet(DescribeSubnetRequest request) {
            return await new DescribeSubnetExecutor().Client(this).Execute<DescribeSubnetResponse, DescribeSubnetResult, DescribeSubnetRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyListenerResponse ModifyListener(ModifyListenerRequest request) {
            return  new ModifyListenerExecutor().Client(this).Execute<ModifyListenerResponse, ModifyListenerResult, ModifyListenerRequest>(request);
        }
#else
        /// <summary>
        ///  修改监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyListenerResponse> ModifyListener(ModifyListenerRequest request) {
            return await new ModifyListenerExecutor().Client(this).Execute<ModifyListenerResponse, ModifyListenerResult, ModifyListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  绑定弹性公网IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssociateElasticIpLBResponse AssociateElasticIpLB(AssociateElasticIpLBRequest request) {
            return  new AssociateElasticIpLBExecutor().Client(this).Execute<AssociateElasticIpLBResponse, AssociateElasticIpLBResult, AssociateElasticIpLBRequest>(request);
        }
#else
        /// <summary>
        ///  绑定弹性公网IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssociateElasticIpLBResponse> AssociateElasticIpLB(AssociateElasticIpLBRequest request) {
            return await new AssociateElasticIpLBExecutor().Client(this).Execute<AssociateElasticIpLBResponse, AssociateElasticIpLBResult, AssociateElasticIpLBRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除私有网络
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteVpcResponse DeleteVpc(DeleteVpcRequest request) {
            return  new DeleteVpcExecutor().Client(this).Execute<DeleteVpcResponse, DeleteVpcResult, DeleteVpcRequest>(request);
        }
#else
        /// <summary>
        ///  删除私有网络
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteVpcResponse> DeleteVpc(DeleteVpcRequest request) {
            return await new DeleteVpcExecutor().Client(this).Execute<DeleteVpcResponse, DeleteVpcResult, DeleteVpcRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询单个云物理服务器硬件监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceStatusResponse DescribeInstanceStatus(DescribeInstanceStatusRequest request) {
            return  new DescribeInstanceStatusExecutor().Client(this).Execute<DescribeInstanceStatusResponse, DescribeInstanceStatusResult, DescribeInstanceStatusRequest>(request);
        }
#else
        /// <summary>
        ///  查询单个云物理服务器硬件监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceStatusResponse> DescribeInstanceStatus(DescribeInstanceStatusRequest request) {
            return await new DescribeInstanceStatusExecutor().Client(this).Execute<DescribeInstanceStatusResponse, DescribeInstanceStatusResult, DescribeInstanceStatusRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  添加后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AddServersResponse AddServers(AddServersRequest request) {
            return  new AddServersExecutor().Client(this).Execute<AddServersResponse, AddServersResult, AddServersRequest>(request);
        }
#else
        /// <summary>
        ///  添加后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AddServersResponse> AddServers(AddServersRequest request) {
            return await new AddServersExecutor().Client(this).Execute<AddServersResponse, AddServersResult, AddServersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  重装云物理服务器，只能重装stopped状态的服务器&lt;br/&gt;
        /// - 可调用接口（describeOS）获取云物理服务器支持的操作系统列表
        ///  [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ReinstallInstanceResponse ReinstallInstance(ReinstallInstanceRequest request) {
            return  new ReinstallInstanceExecutor().Client(this).Execute<ReinstallInstanceResponse, ReinstallInstanceResult, ReinstallInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  重装云物理服务器，只能重装stopped状态的服务器&lt;br/&gt;
        /// - 可调用接口（describeOS）获取云物理服务器支持的操作系统列表
        ///  [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ReinstallInstanceResponse> ReinstallInstance(ReinstallInstanceRequest request) {
            return await new ReinstallInstanceExecutor().Client(this).Execute<ReinstallInstanceResponse, ReinstallInstanceResult, ReinstallInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteServerGroupResponse DeleteServerGroup(DeleteServerGroupRequest request) {
            return  new DeleteServerGroupExecutor().Client(this).Execute<DeleteServerGroupResponse, DeleteServerGroupResult, DeleteServerGroupRequest>(request);
        }
#else
        /// <summary>
        ///  删除虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteServerGroupResponse> DeleteServerGroup(DeleteServerGroupRequest request) {
            return await new DeleteServerGroupExecutor().Client(this).Execute<DeleteServerGroupResponse, DeleteServerGroupResult, DeleteServerGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询密钥对详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeKeypairResponse DescribeKeypair(DescribeKeypairRequest request) {
            return  new DescribeKeypairExecutor().Client(this).Execute<DescribeKeypairResponse, DescribeKeypairResult, DescribeKeypairRequest>(request);
        }
#else
        /// <summary>
        ///  查询密钥对详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeKeypairResponse> DescribeKeypair(DescribeKeypairRequest request) {
            return await new DescribeKeypairExecutor().Client(this).Execute<DescribeKeypairResponse, DescribeKeypairResult, DescribeKeypairRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询某种实例类型的云物理服务器支持的RAID类型，可查询系统盘RAID类型和数据盘RAID类型
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeDeviceRaidsResponse DescribeDeviceRaids(DescribeDeviceRaidsRequest request) {
            return  new DescribeDeviceRaidsExecutor().Client(this).Execute<DescribeDeviceRaidsResponse, DescribeDeviceRaidsResult, DescribeDeviceRaidsRequest>(request);
        }
#else
        /// <summary>
        ///  查询某种实例类型的云物理服务器支持的RAID类型，可查询系统盘RAID类型和数据盘RAID类型
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeDeviceRaidsResponse> DescribeDeviceRaids(DescribeDeviceRaidsRequest request) {
            return await new DescribeDeviceRaidsExecutor().Client(this).Execute<DescribeDeviceRaidsResponse, DescribeDeviceRaidsResult, DescribeDeviceRaidsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改IPv6网关实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyIpv6GatewayResponse ModifyIpv6Gateway(ModifyIpv6GatewayRequest request) {
            return  new ModifyIpv6GatewayExecutor().Client(this).Execute<ModifyIpv6GatewayResponse, ModifyIpv6GatewayResult, ModifyIpv6GatewayRequest>(request);
        }
#else
        /// <summary>
        ///  修改IPv6网关实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyIpv6GatewayResponse> ModifyIpv6Gateway(ModifyIpv6GatewayRequest request) {
            return await new ModifyIpv6GatewayExecutor().Client(this).Execute<ModifyIpv6GatewayResponse, ModifyIpv6GatewayResult, ModifyIpv6GatewayRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  解绑弹性公网IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisassociateElasticIpLBResponse DisassociateElasticIpLB(DisassociateElasticIpLBRequest request) {
            return  new DisassociateElasticIpLBExecutor().Client(this).Execute<DisassociateElasticIpLBResponse, DisassociateElasticIpLBResult, DisassociateElasticIpLBRequest>(request);
        }
#else
        /// <summary>
        ///  解绑弹性公网IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisassociateElasticIpLBResponse> DisassociateElasticIpLB(DisassociateElasticIpLBRequest request) {
            return await new DisassociateElasticIpLBExecutor().Client(this).Execute<DisassociateElasticIpLBResponse, DisassociateElasticIpLBResult, DisassociateElasticIpLBRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询虚拟服务器组列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeServerGroupsResponse DescribeServerGroups(DescribeServerGroupsRequest request) {
            return  new DescribeServerGroupsExecutor().Client(this).Execute<DescribeServerGroupsResponse, DescribeServerGroupsResult, DescribeServerGroupsRequest>(request);
        }
#else
        /// <summary>
        ///  查询虚拟服务器组列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeServerGroupsResponse> DescribeServerGroups(DescribeServerGroupsRequest request) {
            return await new DescribeServerGroupsExecutor().Client(this).Execute<DescribeServerGroupsResponse, DescribeServerGroupsResult, DescribeServerGroupsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改私有网络
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyVpcResponse ModifyVpc(ModifyVpcRequest request) {
            return  new ModifyVpcExecutor().Client(this).Execute<ModifyVpcResponse, ModifyVpcResult, ModifyVpcRequest>(request);
        }
#else
        /// <summary>
        ///  修改私有网络
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyVpcResponse> ModifyVpc(ModifyVpcRequest request) {
            return await new ModifyVpcExecutor().Client(this).Execute<ModifyVpcResponse, ModifyVpcResult, ModifyVpcRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改IPv6公网带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyIpv6AddressBandwidthResponse ModifyIpv6AddressBandwidth(ModifyIpv6AddressBandwidthRequest request) {
            return  new ModifyIpv6AddressBandwidthExecutor().Client(this).Execute<ModifyIpv6AddressBandwidthResponse, ModifyIpv6AddressBandwidthResult, ModifyIpv6AddressBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  修改IPv6公网带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyIpv6AddressBandwidthResponse> ModifyIpv6AddressBandwidth(ModifyIpv6AddressBandwidthRequest request) {
            return await new ModifyIpv6AddressBandwidthExecutor().Client(this).Execute<ModifyIpv6AddressBandwidthResponse, ModifyIpv6AddressBandwidthResult, ModifyIpv6AddressBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除别名IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteAliasIpResponse DeleteAliasIp(DeleteAliasIpRequest request) {
            return  new DeleteAliasIpExecutor().Client(this).Execute<DeleteAliasIpResponse, DeleteAliasIpResult, DeleteAliasIpRequest>(request);
        }
#else
        /// <summary>
        ///  删除别名IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteAliasIpResponse> DeleteAliasIp(DeleteAliasIpRequest request) {
            return await new DeleteAliasIpExecutor().Client(this).Execute<DeleteAliasIpResponse, DeleteAliasIpResult, DeleteAliasIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询证书详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeCertResponse DescribeCert(DescribeCertRequest request) {
            return  new DescribeCertExecutor().Client(this).Execute<DescribeCertResponse, DescribeCertResult, DescribeCertRequest>(request);
        }
#else
        /// <summary>
        ///  查询证书详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeCertResponse> DescribeCert(DescribeCertRequest request) {
            return await new DescribeCertExecutor().Client(this).Execute<DescribeCertResponse, DescribeCertResult, DescribeCertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceNameResponse DescribeInstanceName(DescribeInstanceNameRequest request) {
            return  new DescribeInstanceNameExecutor().Client(this).Execute<DescribeInstanceNameResponse, DescribeInstanceNameResult, DescribeInstanceNameRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceNameResponse> DescribeInstanceName(DescribeInstanceNameRequest request) {
            return await new DescribeInstanceNameExecutor().Client(this).Execute<DescribeInstanceNameResponse, DescribeInstanceNameResult, DescribeInstanceNameRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifySubnetResponse ModifySubnet(ModifySubnetRequest request) {
            return  new ModifySubnetExecutor().Client(this).Execute<ModifySubnetResponse, ModifySubnetResult, ModifySubnetRequest>(request);
        }
#else
        /// <summary>
        ///  修改子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifySubnetResponse> ModifySubnet(ModifySubnetRequest request) {
            return await new ModifySubnetExecutor().Client(this).Execute<ModifySubnetResponse, ModifySubnetResult, ModifySubnetRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询私有网络列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeVpcsResponse DescribeVpcs(DescribeVpcsRequest request) {
            return  new DescribeVpcsExecutor().Client(this).Execute<DescribeVpcsResponse, DescribeVpcsResult, DescribeVpcsRequest>(request);
        }
#else
        /// <summary>
        ///  查询私有网络列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeVpcsResponse> DescribeVpcs(DescribeVpcsRequest request) {
            return await new DescribeVpcsExecutor().Client(this).Execute<DescribeVpcsResponse, DescribeVpcsResult, DescribeVpcsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询IPv6网关实例列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeIpv6GatewaysResponse DescribeIpv6Gateways(DescribeIpv6GatewaysRequest request) {
            return  new DescribeIpv6GatewaysExecutor().Client(this).Execute<DescribeIpv6GatewaysResponse, DescribeIpv6GatewaysResult, DescribeIpv6GatewaysRequest>(request);
        }
#else
        /// <summary>
        ///  查询IPv6网关实例列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeIpv6GatewaysResponse> DescribeIpv6Gateways(DescribeIpv6GatewaysRequest request) {
            return await new DescribeIpv6GatewaysExecutor().Client(this).Execute<DescribeIpv6GatewaysResponse, DescribeIpv6GatewaysResult, DescribeIpv6GatewaysRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量关闭云物理服务器，只能停止running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopInstancesResponse StopInstances(StopInstancesRequest request) {
            return  new StopInstancesExecutor().Client(this).Execute<StopInstancesResponse, StopInstancesResult, StopInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  批量关闭云物理服务器，只能停止running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopInstancesResponse> StopInstances(StopInstancesRequest request) {
            return await new StopInstancesExecutor().Client(this).Execute<StopInstancesResponse, StopInstancesResult, StopInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询单个云物理服务器已安装的RAID信息，包括系统盘RAID信息和数据盘RAID信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceRaidResponse DescribeInstanceRaid(DescribeInstanceRaidRequest request) {
            return  new DescribeInstanceRaidExecutor().Client(this).Execute<DescribeInstanceRaidResponse, DescribeInstanceRaidResult, DescribeInstanceRaidRequest>(request);
        }
#else
        /// <summary>
        ///  查询单个云物理服务器已安装的RAID信息，包括系统盘RAID信息和数据盘RAID信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceRaidResponse> DescribeInstanceRaid(DescribeInstanceRaidRequest request) {
            return await new DescribeInstanceRaidExecutor().Client(this).Execute<DescribeInstanceRaidResponse, DescribeInstanceRaidResult, DescribeInstanceRaidRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询IPv6地址例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeIpv6AddressResponse DescribeIpv6Address(DescribeIpv6AddressRequest request) {
            return  new DescribeIpv6AddressExecutor().Client(this).Execute<DescribeIpv6AddressResponse, DescribeIpv6AddressResult, DescribeIpv6AddressRequest>(request);
        }
#else
        /// <summary>
        ///  查询IPv6地址例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeIpv6AddressResponse> DescribeIpv6Address(DescribeIpv6AddressRequest request) {
            return await new DescribeIpv6AddressExecutor().Client(this).Execute<DescribeIpv6AddressResponse, DescribeIpv6AddressResult, DescribeIpv6AddressRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeListenersResponse DescribeListeners(DescribeListenersRequest request) {
            return  new DescribeListenersExecutor().Client(this).Execute<DescribeListenersResponse, DescribeListenersResult, DescribeListenersRequest>(request);
        }
#else
        /// <summary>
        ///  查询监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeListenersResponse> DescribeListeners(DescribeListenersRequest request) {
            return await new DescribeListenersExecutor().Client(this).Execute<DescribeListenersResponse, DescribeListenersResult, DescribeListenersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器地域列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeRegionesResponse DescribeRegiones(DescribeRegionesRequest request) {
            return  new DescribeRegionesExecutor().Client(this).Execute<DescribeRegionesResponse, DescribeRegionesResult, DescribeRegionesRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器地域列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeRegionesResponse> DescribeRegiones(DescribeRegionesRequest request) {
            return await new DescribeRegionesExecutor().Client(this).Execute<DescribeRegionesResponse, DescribeRegionesResult, DescribeRegionesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建证书
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateCertResponse CreateCert(CreateCertRequest request) {
            return  new CreateCertExecutor().Client(this).Execute<CreateCertResponse, CreateCertResult, CreateCertRequest>(request);
        }
#else
        /// <summary>
        ///  创建证书
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateCertResponse> CreateCert(CreateCertRequest request) {
            return await new CreateCertExecutor().Client(this).Execute<CreateCertResponse, CreateCertResult, CreateCertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyServerGroupResponse ModifyServerGroup(ModifyServerGroupRequest request) {
            return  new ModifyServerGroupExecutor().Client(this).Execute<ModifyServerGroupResponse, ModifyServerGroupResult, ModifyServerGroupRequest>(request);
        }
#else
        /// <summary>
        ///  修改虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyServerGroupResponse> ModifyServerGroup(ModifyServerGroupRequest request) {
            return await new ModifyServerGroupExecutor().Client(this).Execute<ModifyServerGroupResponse, ModifyServerGroupResult, ModifyServerGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改云物理服务器部分信息，包括名称、描述
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyInstanceResponse ModifyInstance(ModifyInstanceRequest request) {
            return  new ModifyInstanceExecutor().Client(this).Execute<ModifyInstanceResponse, ModifyInstanceResult, ModifyInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  修改云物理服务器部分信息，包括名称、描述
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyInstanceResponse> ModifyInstance(ModifyInstanceRequest request) {
            return await new ModifyInstanceExecutor().Client(this).Execute<ModifyInstanceResponse, ModifyInstanceResult, ModifyInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询密钥对列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeKeypairsResponse DescribeKeypairs(DescribeKeypairsRequest request) {
            return  new DescribeKeypairsExecutor().Client(this).Execute<DescribeKeypairsResponse, DescribeKeypairsResult, DescribeKeypairsRequest>(request);
        }
#else
        /// <summary>
        ///  查询密钥对列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeKeypairsResponse> DescribeKeypairs(DescribeKeypairsRequest request) {
            return await new DescribeKeypairsExecutor().Client(this).Execute<DescribeKeypairsResponse, DescribeKeypairsResult, DescribeKeypairsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  申请开通IPv6网关
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssignIpv6GatewayResponse AssignIpv6Gateway(AssignIpv6GatewayRequest request) {
            return  new AssignIpv6GatewayExecutor().Client(this).Execute<AssignIpv6GatewayResponse, AssignIpv6GatewayResult, AssignIpv6GatewayRequest>(request);
        }
#else
        /// <summary>
        ///  申请开通IPv6网关
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssignIpv6GatewayResponse> AssignIpv6Gateway(AssignIpv6GatewayRequest request) {
            return await new AssignIpv6GatewayExecutor().Client(this).Execute<AssignIpv6GatewayResponse, AssignIpv6GatewayResult, AssignIpv6GatewayRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器实例类型
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeDeviceTypesResponse DescribeDeviceTypes(DescribeDeviceTypesRequest request) {
            return  new DescribeDeviceTypesExecutor().Client(this).Execute<DescribeDeviceTypesResponse, DescribeDeviceTypesResult, DescribeDeviceTypesRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器实例类型
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeDeviceTypesResponse> DescribeDeviceTypes(DescribeDeviceTypesRequest request) {
            return await new DescribeDeviceTypesExecutor().Client(this).Execute<DescribeDeviceTypesResponse, DescribeDeviceTypesResult, DescribeDeviceTypesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  解绑弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisassociateElasticIpResponse DisassociateElasticIp(DisassociateElasticIpRequest request) {
            return  new DisassociateElasticIpExecutor().Client(this).Execute<DisassociateElasticIpResponse, DisassociateElasticIpResult, DisassociateElasticIpRequest>(request);
        }
#else
        /// <summary>
        ///  解绑弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisassociateElasticIpResponse> DisassociateElasticIp(DisassociateElasticIpRequest request) {
            return await new DisassociateElasticIpExecutor().Client(this).Execute<DisassociateElasticIpResponse, DisassociateElasticIpResult, DisassociateElasticIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询弹性公网IP详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeElasticIpResponse DescribeElasticIp(DescribeElasticIpRequest request) {
            return  new DescribeElasticIpExecutor().Client(this).Execute<DescribeElasticIpResponse, DescribeElasticIpResult, DescribeElasticIpRequest>(request);
        }
#else
        /// <summary>
        ///  查询弹性公网IP详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeElasticIpResponse> DescribeElasticIp(DescribeElasticIpRequest request) {
            return await new DescribeElasticIpExecutor().Client(this).Execute<DescribeElasticIpResponse, DescribeElasticIpResult, DescribeElasticIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量重启云物理服务器，只能重启running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestartInstancesResponse RestartInstances(RestartInstancesRequest request) {
            return  new RestartInstancesExecutor().Client(this).Execute<RestartInstancesResponse, RestartInstancesResult, RestartInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  批量重启云物理服务器，只能重启running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestartInstancesResponse> RestartInstances(RestartInstancesRequest request) {
            return await new RestartInstancesExecutor().Client(this).Execute<RestartInstancesResponse, RestartInstancesResult, RestartInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除次要CIDR
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteSecondaryCidrResponse DeleteSecondaryCidr(DeleteSecondaryCidrRequest request) {
            return  new DeleteSecondaryCidrExecutor().Client(this).Execute<DeleteSecondaryCidrResponse, DeleteSecondaryCidrResult, DeleteSecondaryCidrRequest>(request);
        }
#else
        /// <summary>
        ///  删除次要CIDR
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteSecondaryCidrResponse> DeleteSecondaryCidr(DeleteSecondaryCidrRequest request) {
            return await new DeleteSecondaryCidrExecutor().Client(this).Execute<DeleteSecondaryCidrResponse, DeleteSecondaryCidrResult, DeleteSecondaryCidrRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询次要CIDR列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSecondaryCidrsResponse DescribeSecondaryCidrs(DescribeSecondaryCidrsRequest request) {
            return  new DescribeSecondaryCidrsExecutor().Client(this).Execute<DescribeSecondaryCidrsResponse, DescribeSecondaryCidrsResult, DescribeSecondaryCidrsRequest>(request);
        }
#else
        /// <summary>
        ///  查询次要CIDR列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSecondaryCidrsResponse> DescribeSecondaryCidrs(DescribeSecondaryCidrsRequest request) {
            return await new DescribeSecondaryCidrsExecutor().Client(this).Execute<DescribeSecondaryCidrsResponse, DescribeSecondaryCidrsResult, DescribeSecondaryCidrsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询SLB名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSlbsNameResponse DescribeSlbsName(DescribeSlbsNameRequest request) {
            return  new DescribeSlbsNameExecutor().Client(this).Execute<DescribeSlbsNameResponse, DescribeSlbsNameResult, DescribeSlbsNameRequest>(request);
        }
#else
        /// <summary>
        ///  查询SLB名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSlbsNameResponse> DescribeSlbsName(DescribeSlbsNameRequest request) {
            return await new DescribeSlbsNameExecutor().Client(this).Execute<DescribeSlbsNameResponse, DescribeSlbsNameResult, DescribeSlbsNameRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyLoadBalancerResponse ModifyLoadBalancer(ModifyLoadBalancerRequest request) {
            return  new ModifyLoadBalancerExecutor().Client(this).Execute<ModifyLoadBalancerResponse, ModifyLoadBalancerResult, ModifyLoadBalancerRequest>(request);
        }
#else
        /// <summary>
        ///  修改负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyLoadBalancerResponse> ModifyLoadBalancer(ModifyLoadBalancerRequest request) {
            return await new ModifyLoadBalancerExecutor().Client(this).Execute<ModifyLoadBalancerResponse, ModifyLoadBalancerResult, ModifyLoadBalancerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StartLoadBalancerResponse StartLoadBalancer(StartLoadBalancerRequest request) {
            return  new StartLoadBalancerExecutor().Client(this).Execute<StartLoadBalancerResponse, StartLoadBalancerResult, StartLoadBalancerRequest>(request);
        }
#else
        /// <summary>
        ///  开启负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StartLoadBalancerResponse> StartLoadBalancer(StartLoadBalancerRequest request) {
            return await new StartLoadBalancerExecutor().Client(this).Execute<StartLoadBalancerResponse, StartLoadBalancerResult, StartLoadBalancerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询路由表列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeRouteTablesResponse DescribeRouteTables(DescribeRouteTablesRequest request) {
            return  new DescribeRouteTablesExecutor().Client(this).Execute<DescribeRouteTablesResponse, DescribeRouteTablesResult, DescribeRouteTablesRequest>(request);
        }
#else
        /// <summary>
        ///  查询路由表列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeRouteTablesResponse> DescribeRouteTables(DescribeRouteTablesRequest request) {
            return await new DescribeRouteTablesExecutor().Client(this).Execute<DescribeRouteTablesResponse, DescribeRouteTablesResult, DescribeRouteTablesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopLoadBalancerResponse StopLoadBalancer(StopLoadBalancerRequest request) {
            return  new StopLoadBalancerExecutor().Client(this).Execute<StopLoadBalancerResponse, StopLoadBalancerResult, StopLoadBalancerRequest>(request);
        }
#else
        /// <summary>
        ///  关闭负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopLoadBalancerResponse> StopLoadBalancer(StopLoadBalancerRequest request) {
            return await new StopLoadBalancerExecutor().Client(this).Execute<StopLoadBalancerResponse, StopLoadBalancerResult, StopLoadBalancerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询单台云物理服务器详细信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceResponse DescribeInstance(DescribeInstanceRequest request) {
            return  new DescribeInstanceExecutor().Client(this).Execute<DescribeInstanceResponse, DescribeInstanceResult, DescribeInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  查询单台云物理服务器详细信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceResponse> DescribeInstance(DescribeInstanceRequest request) {
            return await new DescribeInstanceExecutor().Client(this).Execute<DescribeInstanceResponse, DescribeInstanceResult, DescribeInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  升级云物理服务器外网带宽，只能操作running或者stopped状态的服务器&lt;br/&gt;
        /// - 不支持未启用外网的服务器升级带宽
        /// - 外网带宽不支持降级
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyBandwidthResponse ModifyBandwidth(ModifyBandwidthRequest request) {
            return  new ModifyBandwidthExecutor().Client(this).Execute<ModifyBandwidthResponse, ModifyBandwidthResult, ModifyBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  升级云物理服务器外网带宽，只能操作running或者stopped状态的服务器&lt;br/&gt;
        /// - 不支持未启用外网的服务器升级带宽
        /// - 外网带宽不支持降级
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyBandwidthResponse> ModifyBandwidth(ModifyBandwidthRequest request) {
            return await new ModifyBandwidthExecutor().Client(this).Execute<ModifyBandwidthResponse, ModifyBandwidthResult, ModifyBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  申请IPv6地址
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssignIpv6AddressResponse AssignIpv6Address(AssignIpv6AddressRequest request) {
            return  new AssignIpv6AddressExecutor().Client(this).Execute<AssignIpv6AddressResponse, AssignIpv6AddressResult, AssignIpv6AddressRequest>(request);
        }
#else
        /// <summary>
        ///  申请IPv6地址
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssignIpv6AddressResponse> AssignIpv6Address(AssignIpv6AddressRequest request) {
            return await new AssignIpv6AddressExecutor().Client(this).Execute<AssignIpv6AddressResponse, AssignIpv6AddressResult, AssignIpv6AddressRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceMonitorInfoResponse DescribeInstanceMonitorInfo(DescribeInstanceMonitorInfoRequest request) {
            return  new DescribeInstanceMonitorInfoExecutor().Client(this).Execute<DescribeInstanceMonitorInfoResponse, DescribeInstanceMonitorInfoResult, DescribeInstanceMonitorInfoRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceMonitorInfoResponse> DescribeInstanceMonitorInfo(DescribeInstanceMonitorInfoRequest request) {
            return await new DescribeInstanceMonitorInfoExecutor().Client(this).Execute<DescribeInstanceMonitorInfoResponse, DescribeInstanceMonitorInfoResult, DescribeInstanceMonitorInfoRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一台或多台指定配置的云物理服务器&lt;br/&gt;
        /// - 地域与可用区&lt;br/&gt;
        ///   - 调用接口（describeRegiones）获取云物理服务器支持的地域与可用区&lt;br/&gt;
        /// - 实例类型&lt;br/&gt;
        ///   - 调用接口（describeDeviceTypes）获取物理实例类型列表&lt;br/&gt;
        ///   - 不能使用已下线、或已售馨的实例类型&lt;br/&gt;
        /// - 操作系统&lt;br/&gt;
        ///   - 可调用接口（describeOS）获取云物理服务器支持的操作系统列表&lt;br/&gt;
        /// - 存储&lt;br/&gt;
        ///   - 数据盘多种RAID可选，可调用接口（describeDeviceRaids）获取服务器支持的RAID列表&lt;br/&gt;
        /// - 网络&lt;br/&gt;
        ///   - 网络类型目前支持basic、vpc&lt;br/&gt;
        ///   - 线路目前只支持bgp&lt;br/&gt;
        ///   - 支持不启用外网，如果启用外网，带宽范围[1,200] 单位Mbps&lt;br/&gt;
        /// - 其他&lt;br/&gt;
        ///   - 购买时长，可按年或月购买：月取值范围[1,9], 年取值范围[1,3]&lt;br/&gt;
        ///   - 密码设置参考公共参数规范&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateInstancesResponse CreateInstances(CreateInstancesRequest request) {
            return  new CreateInstancesExecutor().Client(this).Execute<CreateInstancesResponse, CreateInstancesResult, CreateInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  创建一台或多台指定配置的云物理服务器&lt;br/&gt;
        /// - 地域与可用区&lt;br/&gt;
        ///   - 调用接口（describeRegiones）获取云物理服务器支持的地域与可用区&lt;br/&gt;
        /// - 实例类型&lt;br/&gt;
        ///   - 调用接口（describeDeviceTypes）获取物理实例类型列表&lt;br/&gt;
        ///   - 不能使用已下线、或已售馨的实例类型&lt;br/&gt;
        /// - 操作系统&lt;br/&gt;
        ///   - 可调用接口（describeOS）获取云物理服务器支持的操作系统列表&lt;br/&gt;
        /// - 存储&lt;br/&gt;
        ///   - 数据盘多种RAID可选，可调用接口（describeDeviceRaids）获取服务器支持的RAID列表&lt;br/&gt;
        /// - 网络&lt;br/&gt;
        ///   - 网络类型目前支持basic、vpc&lt;br/&gt;
        ///   - 线路目前只支持bgp&lt;br/&gt;
        ///   - 支持不启用外网，如果启用外网，带宽范围[1,200] 单位Mbps&lt;br/&gt;
        /// - 其他&lt;br/&gt;
        ///   - 购买时长，可按年或月购买：月取值范围[1,9], 年取值范围[1,3]&lt;br/&gt;
        ///   - 密码设置参考公共参数规范&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateInstancesResponse> CreateInstances(CreateInstancesRequest request) {
            return await new CreateInstancesExecutor().Client(this).Execute<CreateInstancesResponse, CreateInstancesResult, CreateInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  重置云物理服务器密码
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ResetPasswordResponse ResetPassword(ResetPasswordRequest request) {
            return  new ResetPasswordExecutor().Client(this).Execute<ResetPasswordResponse, ResetPasswordResult, ResetPasswordRequest>(request);
        }
#else
        /// <summary>
        ///  重置云物理服务器密码
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ResetPasswordResponse> ResetPassword(ResetPasswordRequest request) {
            return await new ResetPasswordExecutor().Client(this).Execute<ResetPasswordResponse, ResetPasswordResult, ResetPasswordRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  绑定弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssociateElasticIpResponse AssociateElasticIp(AssociateElasticIpRequest request) {
            return  new AssociateElasticIpExecutor().Client(this).Execute<AssociateElasticIpResponse, AssociateElasticIpResult, AssociateElasticIpRequest>(request);
        }
#else
        /// <summary>
        ///  绑定弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssociateElasticIpResponse> AssociateElasticIp(AssociateElasticIpRequest request) {
            return await new AssociateElasticIpExecutor().Client(this).Execute<AssociateElasticIpResponse, AssociateElasticIpResult, AssociateElasticIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询监听器详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeListenerResponse DescribeListener(DescribeListenerRequest request) {
            return  new DescribeListenerExecutor().Client(this).Execute<DescribeListenerResponse, DescribeListenerResult, DescribeListenerRequest>(request);
        }
#else
        /// <summary>
        ///  查询监听器详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeListenerResponse> DescribeListener(DescribeListenerRequest request) {
            return await new DescribeListenerExecutor().Client(this).Execute<DescribeListenerResponse, DescribeListenerResult, DescribeListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  对单台云物理服务器执行关机操作，只能停止running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopInstanceResponse StopInstance(StopInstanceRequest request) {
            return  new StopInstanceExecutor().Client(this).Execute<StopInstanceResponse, StopInstanceResult, StopInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  对单台云物理服务器执行关机操作，只能停止running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopInstanceResponse> StopInstance(StopInstanceRequest request) {
            return await new StopInstanceExecutor().Client(this).Execute<StopInstanceResponse, StopInstanceResult, StopInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询私有网络详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeVpcResponse DescribeVpc(DescribeVpcRequest request) {
            return  new DescribeVpcExecutor().Client(this).Execute<DescribeVpcResponse, DescribeVpcResult, DescribeVpcRequest>(request);
        }
#else
        /// <summary>
        ///  查询私有网络详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeVpcResponse> DescribeVpc(DescribeVpcRequest request) {
            return await new DescribeVpcExecutor().Client(this).Execute<DescribeVpcResponse, DescribeVpcResult, DescribeVpcRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询子网列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSubnetsResponse DescribeSubnets(DescribeSubnetsRequest request) {
            return  new DescribeSubnetsExecutor().Client(this).Execute<DescribeSubnetsResponse, DescribeSubnetsResult, DescribeSubnetsRequest>(request);
        }
#else
        /// <summary>
        ///  查询子网列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSubnetsResponse> DescribeSubnets(DescribeSubnetsRequest request) {
            return await new DescribeSubnetsExecutor().Client(this).Execute<DescribeSubnetsResponse, DescribeSubnetsResult, DescribeSubnetsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量开启云物理服务器，只能启动stopped状态的服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StartInstancesResponse StartInstances(StartInstancesRequest request) {
            return  new StartInstancesExecutor().Client(this).Execute<StartInstancesResponse, StartInstancesResult, StartInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  批量开启云物理服务器，只能启动stopped状态的服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StartInstancesResponse> StartInstances(StartInstancesRequest request) {
            return await new StartInstancesExecutor().Client(this).Execute<StartInstancesResponse, StartInstancesResult, StartInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  申请弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ApplyElasticIpsResponse ApplyElasticIps(ApplyElasticIpsRequest request) {
            return  new ApplyElasticIpsExecutor().Client(this).Execute<ApplyElasticIpsResponse, ApplyElasticIpsResult, ApplyElasticIpsRequest>(request);
        }
#else
        /// <summary>
        ///  申请弹性公网IP
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ApplyElasticIpsResponse> ApplyElasticIps(ApplyElasticIpsRequest request) {
            return await new ApplyElasticIpsExecutor().Client(this).Execute<ApplyElasticIpsResponse, ApplyElasticIpsResult, ApplyElasticIpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteListenerResponse DeleteListener(DeleteListenerRequest request) {
            return  new DeleteListenerExecutor().Client(this).Execute<DeleteListenerResponse, DeleteListenerResult, DeleteListenerRequest>(request);
        }
#else
        /// <summary>
        ///  删除监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteListenerResponse> DeleteListener(DeleteListenerRequest request) {
            return await new DeleteListenerExecutor().Client(this).Execute<DeleteListenerResponse, DeleteListenerResult, DeleteListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateKeypairsResponse CreateKeypairs(CreateKeypairsRequest request) {
            return  new CreateKeypairsExecutor().Client(this).Execute<CreateKeypairsResponse, CreateKeypairsResult, CreateKeypairsRequest>(request);
        }
#else
        /// <summary>
        ///  创建密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateKeypairsResponse> CreateKeypairs(CreateKeypairsRequest request) {
            return await new CreateKeypairsExecutor().Client(this).Execute<CreateKeypairsResponse, CreateKeypairsResult, CreateKeypairsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  申请IPv6地址带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssignIpv6AddressesBandwidthResponse AssignIpv6AddressesBandwidth(AssignIpv6AddressesBandwidthRequest request) {
            return  new AssignIpv6AddressesBandwidthExecutor().Client(this).Execute<AssignIpv6AddressesBandwidthResponse, AssignIpv6AddressesBandwidthResult, AssignIpv6AddressesBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  申请IPv6地址带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssignIpv6AddressesBandwidthResponse> AssignIpv6AddressesBandwidth(AssignIpv6AddressesBandwidthRequest request) {
            return await new AssignIpv6AddressesBandwidthExecutor().Client(this).Execute<AssignIpv6AddressesBandwidthResponse, AssignIpv6AddressesBandwidthResult, AssignIpv6AddressesBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  移除后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RemoveServerResponse RemoveServer(RemoveServerRequest request) {
            return  new RemoveServerExecutor().Client(this).Execute<RemoveServerResponse, RemoveServerResult, RemoveServerRequest>(request);
        }
#else
        /// <summary>
        ///  移除后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RemoveServerResponse> RemoveServer(RemoveServerRequest request) {
            return await new RemoveServerExecutor().Client(this).Execute<RemoveServerResponse, RemoveServerResult, RemoveServerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  导入密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ImportKeypairsResponse ImportKeypairs(ImportKeypairsRequest request) {
            return  new ImportKeypairsExecutor().Client(this).Execute<ImportKeypairsResponse, ImportKeypairsResult, ImportKeypairsRequest>(request);
        }
#else
        /// <summary>
        ///  导入密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ImportKeypairsResponse> ImportKeypairs(ImportKeypairsRequest request) {
            return await new ImportKeypairsExecutor().Client(this).Execute<ImportKeypairsResponse, ImportKeypairsResult, ImportKeypairsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateServerGroupResponse CreateServerGroup(CreateServerGroupRequest request) {
            return  new CreateServerGroupExecutor().Client(this).Execute<CreateServerGroupResponse, CreateServerGroupResult, CreateServerGroupRequest>(request);
        }
#else
        /// <summary>
        ///  创建虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateServerGroupResponse> CreateServerGroup(CreateServerGroupRequest request) {
            return await new CreateServerGroupExecutor().Client(this).Execute<CreateServerGroupResponse, CreateServerGroupResult, CreateServerGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StartListenerResponse StartListener(StartListenerRequest request) {
            return  new StartListenerExecutor().Client(this).Execute<StartListenerResponse, StartListenerResult, StartListenerRequest>(request);
        }
#else
        /// <summary>
        ///  开启监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StartListenerResponse> StartListener(StartListenerRequest request) {
            return await new StartListenerExecutor().Client(this).Execute<StartListenerResponse, StartListenerResult, StartListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询负载均衡实例列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeLoadBalancersResponse DescribeLoadBalancers(DescribeLoadBalancersRequest request) {
            return  new DescribeLoadBalancersExecutor().Client(this).Execute<DescribeLoadBalancersResponse, DescribeLoadBalancersResult, DescribeLoadBalancersRequest>(request);
        }
#else
        /// <summary>
        ///  查询负载均衡实例列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeLoadBalancersResponse> DescribeLoadBalancers(DescribeLoadBalancersRequest request) {
            return await new DescribeLoadBalancersExecutor().Client(this).Execute<DescribeLoadBalancersResponse, DescribeLoadBalancersResult, DescribeLoadBalancersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询EIP名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeElasticIpNameResponse DescribeElasticIpName(DescribeElasticIpNameRequest request) {
            return  new DescribeElasticIpNameExecutor().Client(this).Execute<DescribeElasticIpNameResponse, DescribeElasticIpNameResult, DescribeElasticIpNameRequest>(request);
        }
#else
        /// <summary>
        ///  查询EIP名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeElasticIpNameResponse> DescribeElasticIpName(DescribeElasticIpNameRequest request) {
            return await new DescribeElasticIpNameExecutor().Client(this).Execute<DescribeElasticIpNameResponse, DescribeElasticIpNameResult, DescribeElasticIpNameRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  对单台云物理服务器执行开机操作，只能启动stopped状态的服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StartInstanceResponse StartInstance(StartInstanceRequest request) {
            return  new StartInstanceExecutor().Client(this).Execute<StartInstanceResponse, StartInstanceResult, StartInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  对单台云物理服务器执行开机操作，只能启动stopped状态的服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StartInstanceResponse> StartInstance(StartInstanceRequest request) {
            return await new StartInstanceExecutor().Client(this).Execute<StartInstanceResponse, StartInstanceResult, StartInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询IPv6网关实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeIpv6GatewayResponse DescribeIpv6Gateway(DescribeIpv6GatewayRequest request) {
            return  new DescribeIpv6GatewayExecutor().Client(this).Execute<DescribeIpv6GatewayResponse, DescribeIpv6GatewayResult, DescribeIpv6GatewayRequest>(request);
        }
#else
        /// <summary>
        ///  查询IPv6网关实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeIpv6GatewayResponse> DescribeIpv6Gateway(DescribeIpv6GatewayRequest request) {
            return await new DescribeIpv6GatewayExecutor().Client(this).Execute<DescribeIpv6GatewayResponse, DescribeIpv6GatewayResult, DescribeIpv6GatewayRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  申请IPv6网段
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AssignIpv6CidrResponse AssignIpv6Cidr(AssignIpv6CidrRequest request) {
            return  new AssignIpv6CidrExecutor().Client(this).Execute<AssignIpv6CidrResponse, AssignIpv6CidrResult, AssignIpv6CidrRequest>(request);
        }
#else
        /// <summary>
        ///  申请IPv6网段
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AssignIpv6CidrResponse> AssignIpv6Cidr(AssignIpv6CidrRequest request) {
            return await new AssignIpv6CidrExecutor().Client(this).Execute<AssignIpv6CidrResponse, AssignIpv6CidrResult, AssignIpv6CidrRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询负载均衡地域列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeCPSLBRegionsResponse DescribeCPSLBRegions(DescribeCPSLBRegionsRequest request) {
            return  new DescribeCPSLBRegionsExecutor().Client(this).Execute<DescribeCPSLBRegionsResponse, DescribeCPSLBRegionsResult, DescribeCPSLBRegionsRequest>(request);
        }
#else
        /// <summary>
        ///  查询负载均衡地域列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeCPSLBRegionsResponse> DescribeCPSLBRegions(DescribeCPSLBRegionsRequest request) {
            return await new DescribeCPSLBRegionsExecutor().Client(this).Execute<DescribeCPSLBRegionsResponse, DescribeCPSLBRegionsResult, DescribeCPSLBRegionsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询路由表详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeRouteTableResponse DescribeRouteTable(DescribeRouteTableRequest request) {
            return  new DescribeRouteTableExecutor().Client(this).Execute<DescribeRouteTableResponse, DescribeRouteTableResult, DescribeRouteTableRequest>(request);
        }
#else
        /// <summary>
        ///  查询路由表详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeRouteTableResponse> DescribeRouteTable(DescribeRouteTableRequest request) {
            return await new DescribeRouteTableExecutor().Client(this).Execute<DescribeRouteTableResponse, DescribeRouteTableResult, DescribeRouteTableRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RemoveCertResponse RemoveCert(RemoveCertRequest request) {
            return  new RemoveCertExecutor().Client(this).Execute<RemoveCertResponse, RemoveCertResult, RemoveCertRequest>(request);
        }
#else
        /// <summary>
        ///  删除证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RemoveCertResponse> RemoveCert(RemoveCertRequest request) {
            return await new RemoveCertExecutor().Client(this).Execute<RemoveCertResponse, RemoveCertResult, RemoveCertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  添加别名IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateAliasIpResponse CreateAliasIp(CreateAliasIpRequest request) {
            return  new CreateAliasIpExecutor().Client(this).Execute<CreateAliasIpResponse, CreateAliasIpResult, CreateAliasIpRequest>(request);
        }
#else
        /// <summary>
        ///  添加别名IP
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateAliasIpResponse> CreateAliasIp(CreateAliasIpRequest request) {
            return await new CreateAliasIpExecutor().Client(this).Execute<CreateAliasIpResponse, CreateAliasIpResult, CreateAliasIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateSubnetResponse CreateSubnet(CreateSubnetRequest request) {
            return  new CreateSubnetExecutor().Client(this).Execute<CreateSubnetResponse, CreateSubnetResult, CreateSubnetRequest>(request);
        }
#else
        /// <summary>
        ///  创建子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateSubnetResponse> CreateSubnet(CreateSubnetRequest request) {
            return await new CreateSubnetExecutor().Client(this).Execute<CreateSubnetResponse, CreateSubnetResult, CreateSubnetRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  重启单台云物理服务器，只能重启running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestartInstanceResponse RestartInstance(RestartInstanceRequest request) {
            return  new RestartInstanceExecutor().Client(this).Execute<RestartInstanceResponse, RestartInstanceResult, RestartInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  重启单台云物理服务器，只能重启running状态的服务器 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestartInstanceResponse> RestartInstance(RestartInstanceRequest request) {
            return await new RestartInstanceExecutor().Client(this).Execute<RestartInstanceResponse, RestartInstanceResult, RestartInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询负载均衡实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeLoadBalancerResponse DescribeLoadBalancer(DescribeLoadBalancerRequest request) {
            return  new DescribeLoadBalancerExecutor().Client(this).Execute<DescribeLoadBalancerResponse, DescribeLoadBalancerResult, DescribeLoadBalancerRequest>(request);
        }
#else
        /// <summary>
        ///  查询负载均衡实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeLoadBalancerResponse> DescribeLoadBalancer(DescribeLoadBalancerRequest request) {
            return await new DescribeLoadBalancerExecutor().Client(this).Execute<DescribeLoadBalancerResponse, DescribeLoadBalancerResult, DescribeLoadBalancerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询弹性公网IP列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeElasticIpsResponse DescribeElasticIps(DescribeElasticIpsRequest request) {
            return  new DescribeElasticIpsExecutor().Client(this).Execute<DescribeElasticIpsResponse, DescribeElasticIpsResult, DescribeElasticIpsRequest>(request);
        }
#else
        /// <summary>
        ///  查询弹性公网IP列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeElasticIpsResponse> DescribeElasticIps(DescribeElasticIpsRequest request) {
            return await new DescribeElasticIpsExecutor().Client(this).Execute<DescribeElasticIpsResponse, DescribeElasticIpsResult, DescribeElasticIpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询IPv6地址列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeIpv6AddressesResponse DescribeIpv6Addresses(DescribeIpv6AddressesRequest request) {
            return  new DescribeIpv6AddressesExecutor().Client(this).Execute<DescribeIpv6AddressesResponse, DescribeIpv6AddressesResult, DescribeIpv6AddressesRequest>(request);
        }
#else
        /// <summary>
        ///  查询IPv6地址列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeIpv6AddressesResponse> DescribeIpv6Addresses(DescribeIpv6AddressesRequest request) {
            return await new DescribeIpv6AddressesExecutor().Client(this).Execute<DescribeIpv6AddressesResponse, DescribeIpv6AddressesResult, DescribeIpv6AddressesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器支持的操作系统
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeOSResponse DescribeOS(DescribeOSRequest request) {
            return  new DescribeOSExecutor().Client(this).Execute<DescribeOSResponse, DescribeOSResult, DescribeOSRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器支持的操作系统
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeOSResponse> DescribeOS(DescribeOSRequest request) {
            return await new DescribeOSExecutor().Client(this).Execute<DescribeOSResponse, DescribeOSResult, DescribeOSRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询云物理服务器监控报警日志信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeEventLogsResponse DescribeEventLogs(DescribeEventLogsRequest request) {
            return  new DescribeEventLogsExecutor().Client(this).Execute<DescribeEventLogsResponse, DescribeEventLogsResult, DescribeEventLogsRequest>(request);
        }
#else
        /// <summary>
        ///  查询云物理服务器监控报警日志信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeEventLogsResponse> DescribeEventLogs(DescribeEventLogsRequest request) {
            return await new DescribeEventLogsExecutor().Client(this).Execute<DescribeEventLogsResponse, DescribeEventLogsResult, DescribeEventLogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改证书名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyCertResponse ModifyCert(ModifyCertRequest request) {
            return  new ModifyCertExecutor().Client(this).Execute<ModifyCertResponse, ModifyCertResult, ModifyCertRequest>(request);
        }
#else
        /// <summary>
        ///  修改证书名称
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyCertResponse> ModifyCert(ModifyCertRequest request) {
            return await new ModifyCertExecutor().Client(this).Execute<ModifyCertResponse, ModifyCertResult, ModifyCertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeServerGroupResponse DescribeServerGroup(DescribeServerGroupRequest request) {
            return  new DescribeServerGroupExecutor().Client(this).Execute<DescribeServerGroupResponse, DescribeServerGroupResult, DescribeServerGroupRequest>(request);
        }
#else
        /// <summary>
        ///  查询虚拟服务器组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeServerGroupResponse> DescribeServerGroup(DescribeServerGroupRequest request) {
            return await new DescribeServerGroupExecutor().Client(this).Execute<DescribeServerGroupResponse, DescribeServerGroupResult, DescribeServerGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateListenerResponse CreateListener(CreateListenerRequest request) {
            return  new CreateListenerExecutor().Client(this).Execute<CreateListenerResponse, CreateListenerResult, CreateListenerRequest>(request);
        }
#else
        /// <summary>
        ///  创建监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateListenerResponse> CreateListener(CreateListenerRequest request) {
            return await new CreateListenerExecutor().Client(this).Execute<CreateListenerResponse, CreateListenerResult, CreateListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改弹性公网IP带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyElasticIpBandwidthResponse ModifyElasticIpBandwidth(ModifyElasticIpBandwidthRequest request) {
            return  new ModifyElasticIpBandwidthExecutor().Client(this).Execute<ModifyElasticIpBandwidthResponse, ModifyElasticIpBandwidthResult, ModifyElasticIpBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  修改弹性公网IP带宽
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyElasticIpBandwidthResponse> ModifyElasticIpBandwidth(ModifyElasticIpBandwidthRequest request) {
            return await new ModifyElasticIpBandwidthExecutor().Client(this).Execute<ModifyElasticIpBandwidthResponse, ModifyElasticIpBandwidthResult, ModifyElasticIpBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  添加次要CIDR
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateSecondaryCidrResponse CreateSecondaryCidr(CreateSecondaryCidrRequest request) {
            return  new CreateSecondaryCidrExecutor().Client(this).Execute<CreateSecondaryCidrResponse, CreateSecondaryCidrResult, CreateSecondaryCidrRequest>(request);
        }
#else
        /// <summary>
        ///  添加次要CIDR
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateSecondaryCidrResponse> CreateSecondaryCidr(CreateSecondaryCidrRequest request) {
            return await new CreateSecondaryCidrExecutor().Client(this).Execute<CreateSecondaryCidrResponse, CreateSecondaryCidrResult, CreateSecondaryCidrRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyServerResponse ModifyServer(ModifyServerRequest request) {
            return  new ModifyServerExecutor().Client(this).Execute<ModifyServerResponse, ModifyServerResult, ModifyServerRequest>(request);
        }
#else
        /// <summary>
        ///  修改后端服务器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyServerResponse> ModifyServer(ModifyServerRequest request) {
            return await new ModifyServerExecutor().Client(this).Execute<ModifyServerResponse, ModifyServerResult, ModifyServerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量查询云物理服务器详细信息&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstancesResponse DescribeInstances(DescribeInstancesRequest request) {
            return  new DescribeInstancesExecutor().Client(this).Execute<DescribeInstancesResponse, DescribeInstancesResult, DescribeInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  批量查询云物理服务器详细信息&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstancesResponse> DescribeInstances(DescribeInstancesRequest request) {
            return await new DescribeInstancesExecutor().Client(this).Execute<DescribeInstancesResponse, DescribeInstancesResult, DescribeInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询可用的私有IP列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAvailablePrivateIpResponse DescribeAvailablePrivateIp(DescribeAvailablePrivateIpRequest request) {
            return  new DescribeAvailablePrivateIpExecutor().Client(this).Execute<DescribeAvailablePrivateIpResponse, DescribeAvailablePrivateIpResult, DescribeAvailablePrivateIpRequest>(request);
        }
#else
        /// <summary>
        ///  查询可用的私有IP列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAvailablePrivateIpResponse> DescribeAvailablePrivateIp(DescribeAvailablePrivateIpRequest request) {
            return await new DescribeAvailablePrivateIpExecutor().Client(this).Execute<DescribeAvailablePrivateIpResponse, DescribeAvailablePrivateIpResult, DescribeAvailablePrivateIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询证书列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeCertsResponse DescribeCerts(DescribeCertsRequest request) {
            return  new DescribeCertsExecutor().Client(this).Execute<DescribeCertsResponse, DescribeCertsResult, DescribeCertsRequest>(request);
        }
#else
        /// <summary>
        ///  查询证书列表&lt;br/&gt;
        /// 支持分页查询，默认每页20条&lt;br/&gt;
        /// 
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeCertsResponse> DescribeCerts(DescribeCertsRequest request) {
            return await new DescribeCertsExecutor().Client(this).Execute<DescribeCertsResponse, DescribeCertsResult, DescribeCertsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request) {
            return  new CreateLoadBalancerExecutor().Client(this).Execute<CreateLoadBalancerResponse, CreateLoadBalancerResult, CreateLoadBalancerRequest>(request);
        }
#else
        /// <summary>
        ///  创建负载均衡实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateLoadBalancerResponse> CreateLoadBalancer(CreateLoadBalancerRequest request) {
            return await new CreateLoadBalancerExecutor().Client(this).Execute<CreateLoadBalancerResponse, CreateLoadBalancerResult, CreateLoadBalancerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建私有网络
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateVpcResponse CreateVpc(CreateVpcRequest request) {
            return  new CreateVpcExecutor().Client(this).Execute<CreateVpcResponse, CreateVpcResult, CreateVpcRequest>(request);
        }
#else
        /// <summary>
        ///  创建私有网络
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateVpcResponse> CreateVpc(CreateVpcRequest request) {
            return await new CreateVpcExecutor().Client(this).Execute<CreateVpcResponse, CreateVpcResult, CreateVpcRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询别名IP列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAliasIpsResponse DescribeAliasIps(DescribeAliasIpsRequest request) {
            return  new DescribeAliasIpsExecutor().Client(this).Execute<DescribeAliasIpsResponse, DescribeAliasIpsResult, DescribeAliasIpsRequest>(request);
        }
#else
        /// <summary>
        ///  查询别名IP列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAliasIpsResponse> DescribeAliasIps(DescribeAliasIpsRequest request) {
            return await new DescribeAliasIpsExecutor().Client(this).Execute<DescribeAliasIpsResponse, DescribeAliasIpsResult, DescribeAliasIpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteKeypairsResponse DeleteKeypairs(DeleteKeypairsRequest request) {
            return  new DeleteKeypairsExecutor().Client(this).Execute<DeleteKeypairsResponse, DeleteKeypairsResult, DeleteKeypairsRequest>(request);
        }
#else
        /// <summary>
        ///  删除密钥对
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteKeypairsResponse> DeleteKeypairs(DeleteKeypairsRequest request) {
            return await new DeleteKeypairsExecutor().Client(this).Execute<DeleteKeypairsResponse, DeleteKeypairsResult, DeleteKeypairsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopListenerResponse StopListener(StopListenerRequest request) {
            return  new StopListenerExecutor().Client(this).Execute<StopListenerResponse, StopListenerResult, StopListenerRequest>(request);
        }
#else
        /// <summary>
        ///  关闭监听器
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopListenerResponse> StopListener(StopListenerRequest request) {
            return await new StopListenerExecutor().Client(this).Execute<StopListenerResponse, StopListenerResult, StopListenerRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteSubnetResponse DeleteSubnet(DeleteSubnetRequest request) {
            return  new DeleteSubnetExecutor().Client(this).Execute<DeleteSubnetResponse, DeleteSubnetResult, DeleteSubnetRequest>(request);
        }
#else
        /// <summary>
        ///  删除子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteSubnetResponse> DeleteSubnet(DeleteSubnetRequest request) {
            return await new DeleteSubnetExecutor().Client(this).Execute<DeleteSubnetResponse, DeleteSubnetResult, DeleteSubnetRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询基础网络子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBasicSubnetResponse DescribeBasicSubnet(DescribeBasicSubnetRequest request) {
            return  new DescribeBasicSubnetExecutor().Client(this).Execute<DescribeBasicSubnetResponse, DescribeBasicSubnetResult, DescribeBasicSubnetRequest>(request);
        }
#else
        /// <summary>
        ///  查询基础网络子网
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBasicSubnetResponse> DescribeBasicSubnet(DescribeBasicSubnetRequest request) {
            return await new DescribeBasicSubnetExecutor().Client(this).Execute<DescribeBasicSubnetResponse, DescribeBasicSubnetResult, DescribeBasicSubnetRequest>(request).ConfigureAwait(false);
        }
#endif

            /// <summary>
            ///  默认CpsClient 构造器 接口
            ///</summary>
            public interface Builder
            {

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>cpsClient 构造器</returns>
                Builder CredentialsProvider(CredentialsProvider provider);

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>cpsClient 构造器</returns>
                Builder Environment(Core.Client.SDKEnvironment environment);

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>cpsClient 构造器</returns>
                Builder HttpRequestConfig(HttpRequestConfig config);

                /// <summary>
                ///  构造CpsClient 对象
                ///</summary>
                CpsClient Build();
            }

            /// <summary>
            ///  默认CpsClient 构造器
            ///</summary>
            public class DefaultBuilder : Builder
            {
                /// <summary>
                ///  CpsClient service client
                /// </summary>
                private  CpsClient cpsClient;

                /// <summary>
                ///  默认CpsClient 构造器构造对象
                ///</summary>
                public DefaultBuilder()
                {
                    cpsClient = new CpsClient();
                }

                /// <summary>
                ///  构造CpsClient 对象
                ///</summary>
                public CpsClient Build()
                {
                    if (cpsClient.CredentialsProvider == null)
                    {
                        //if credentialsProvider not set, try load jdcloud global default  credentials provider
                        cpsClient.credentialsProvider = JdCloud.DefaultInstance.GetCredentialsProvider();
                        if (cpsClient.credentialsProvider == null)
                        {
                            throw new ArgumentNullException("CpsClient build error: jdcloud credentials provider not set");
                        }
                    }
                    if (cpsClient.HttpRequestConfig == null)
                    {
                        cpsClient.httpRequestConfig = JdCloud.DefaultInstance.GetHttpRequestConfig();
                        if (cpsClient.httpRequestConfig == null)
                        {
                        throw new ArgumentNullException("CpsClient build error: http request config not set");
                        }
                    }
                    return cpsClient;
                }

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>cpsClient 构造器</returns>
                public Builder CredentialsProvider(CredentialsProvider provider)
                {
                    cpsClient.credentialsProvider = provider;
                    return this;
                }

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>cpsClient 构造器</returns>
                public Builder Environment(SDKEnvironment environment)
                {
                    cpsClient.environment = environment;
                    return this;
                }

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>cpsClient 构造器</returns>
                public Builder HttpRequestConfig(HttpRequestConfig config)
                {
                    cpsClient.httpRequestConfig = config;
                    return this;
                }
            }
    }
}
